/**
 * API配置管理
 * 统一管理API基础配置、拦截器、认证等
 */
import axios from 'axios'

// Token管理
const TOKEN_KEY = 'auth_token'
const REFRESH_TOKEN_KEY = 'refresh_token'

export class ApiConfig {
  private static instance: ApiConfig
  private axiosInstance: any

  private constructor() {
    // 初始化时不立即获取API URL，而是使用默认值
    const BASE_CONFIG = {
      baseURL: import.meta.env.VITE_API_BASE_URL || 'http://127.0.0.1:8080',
      timeout: 10000,
      headers: {
        'Content-Type': 'application/json'
      }
    }
    
    this.axiosInstance = axios.create(BASE_CONFIG)
    this.setupInterceptors()
    
    // 异步更新API URL
    this.updateApiUrl()
  }
  
  /**
   * 异步更新API URL
   */
  private async updateApiUrl(): Promise<void> {
    try {
      const apiUrl = ApiConfig.getApiUrl()
      this.axiosInstance.defaults.baseURL = apiUrl
      console.log('API URL已更新:', apiUrl)
    } catch (e) {
      console.error('更新API URL失败:', e)
    }
  }

  public static getInstance(): ApiConfig {
    if (!ApiConfig.instance) {
      ApiConfig.instance = new ApiConfig()
    }
    return ApiConfig.instance
  }

  /**
   * 获取token
   */
  public static async getToken(): Promise<string | null> {
    try {
      // 首先尝试从localStorage获取，这是最可靠的方式
      let token = localStorage.getItem(TOKEN_KEY)
      
      // 如果localStorage中没有，尝试从store获取
      if (!token) {
        try {
          const { useUserStore } = await import('../../auth/stores/user')
          const userStore = useUserStore()
          token = userStore.getToken() || null
          
          // 如果从store获取到了token，同步到localStorage
          if (token) {
            localStorage.setItem(TOKEN_KEY, token)
          }
        } catch (e) {
          console.error('Failed to get token from store:', e);
        }
      }
      
      // 添加调试日志
      console.log('ApiConfig.getToken: 获取到token:', token ? '有效' : '无效或为空')
      
      return token
    } catch (e) {
      console.error('Failed to get token:', e);
      return null
    }
  }

  /**
   * 设置token
   */
  public static async setToken(token: string): Promise<void> {
    console.log('ApiConfig.setToken: 准备保存token', token ? '有效' : '无效或为空')
    
    // 总是保存到localStorage，这是最可靠的方式
    localStorage.setItem(TOKEN_KEY, token)
    console.log('ApiConfig.setToken: token已保存到localStorage')
    
    // 同时尝试保存到store
    try {
      const { useUserStore } = await import('../../auth/stores/user')
      const userStore = useUserStore()
      userStore.setToken(token)
      console.log('ApiConfig.setToken: token已保存到userStore')
    } catch (e) {
      console.error('Failed to set token to store:', e);
    }
  }

  /**
   * 清除token
   */
  public static async clearToken(): Promise<void> {
    // 总是清除localStorage中的token
    localStorage.removeItem(TOKEN_KEY)
    localStorage.removeItem(REFRESH_TOKEN_KEY)
    console.log('ApiConfig.clearToken: 已清除localStorage中的token')
    
    // 同时尝试清除store中的token
    try {
      const { useUserStore } = await import('../../auth/stores/user')
      const userStore = useUserStore()
      userStore.clearToken()
      console.log('ApiConfig.clearToken: 已清除userStore中的token')
    } catch (e) {
      console.error('Failed to clear token from store:', e);
    }
  }

  /**
   * 设置拦截器
   */
  private setupInterceptors(): void {
    // 请求拦截器 - 统一添加认证头
    this.axiosInstance.interceptors.request.use(
      async (config: any) => {
        console.log('发送请求:', config.method?.toUpperCase(), config.url, config.data || config.params)
        
        // 登录和注册请求不需要添加Authorization头
        const isAuthRequest = config.url && (
          config.url.includes('/auth/login') || 
          config.url.includes('/auth/register')
        )
        
        if (!isAuthRequest) {
          try {
            // 确保token已同步到localStorage
            let token = localStorage.getItem(TOKEN_KEY)
            
            // 如果localStorage中没有token，尝试从store获取并同步
            if (!token) {
              try {
                const { useUserStore } = await import('../../auth/stores/user')
                const userStore = useUserStore()
                const storeToken = userStore.token
                
                if (storeToken) {
                  localStorage.setItem(TOKEN_KEY, storeToken)
                  token = storeToken
                  console.log('请求拦截器: 已从store同步token到localStorage')
                }
              } catch (e) {
                console.error('请求拦截器: 获取store token失败', e)
              }
            }
            
            // 如果仍然没有token，尝试通过ApiConfig获取
            if (!token) {
              token = await ApiConfig.getToken()
            }
            
            if (token && config.headers) {
              config.headers.Authorization = `Bearer ${token}`
            }
          } catch (e) {
            console.error('请求拦截器: 获取token失败', e)
          }
        } else {
          console.log('请求拦截器: 跳过认证请求的Authorization头添加')
        }
        
        return config
      },
      (error: any) => {
        console.error('请求拦截器错误:', error)
        return Promise.reject(error)
      }
    )

    // 响应拦截器 - 统一错误处理
    this.axiosInstance.interceptors.response.use(
      async (response: any) => {
        console.log('收到响应:', response.config.method?.toUpperCase(), response.config.url, response.status, response.data)
        
        // 移除对响应体中认证错误的检查，只处理真正的HTTP 401错误
        // 这里不需要处理，因为真正的401错误会被下面的错误拦截器捕获
        
        return response
      },
      async (error: any) => {
        console.error('响应错误:', error.config?.method?.toUpperCase(), error.config?.url, error.response?.status, error.response?.data || error.message)
        
        // 只处理真正的 HTTP 401 状态码
        if (error.response?.status === 401) {
          console.log('检测到401认证错误，清除token并显示登录弹窗')
          
          // 清除token
          await ApiConfig.clearToken()
          
          // 清除Pinia中的用户信息
          try {
            const { useUserStore } = await import('../../auth/stores/user')
            const userStore = useUserStore()
            userStore.setUserInfo(null)
          } catch (e) {
            console.error('Failed to clear user info:', e)
          }
          
          // 触发全局认证错误事件，显示登录遮罩
          window.dispatchEvent(new CustomEvent('auth-error', { 
            detail: { 
              message: error.response?.data?.msg || '认证失败，请重新登录',
              status: 401
            } 
          }))
        }
        
        return Promise.reject(error)
      }
    )
  }

  /**
   * 获取axios实例
   */
  public getAxiosInstance(): any {
    return this.axiosInstance
  }

  /**
   * 创建请求配置
   */
  public createRequestConfig(config?: any): any {
    const BASE_CONFIG = {
      baseURL: ApiConfig.getApiUrl(),
      timeout: 10000,
      headers: {
        'Content-Type': 'application/json'
      }
    }
    
    return {
      ...BASE_CONFIG,
      ...config
    }
  }

  /**
   * 获取API基础URL
   * @returns API基础URL
   */
  static getApiUrl(): string {
    // 优先使用用户设置的API地址
    let apiUrl = ''
    
    // 检查是否在Electron环境中运行
    const isElectron = typeof window !== 'undefined' && window.electronAPI
    
    // 如果是Electron环境，检查是否是开发环境
    if (isElectron && window.electronAPI) {
      try {
        // 优先使用新的 isDevMode 方法，如果不存在则使用旧的 isDev 方法
        const isDev = window.electronAPI.isDevModeSync ? window.electronAPI.isDevModeSync() : 
                      (window.electronAPI.isDevSync ? window.electronAPI.isDevSync() : false)
        
        console.log(`Electron环境 - 开发模式: ${isDev}`)
      } catch (e) {
        console.error('获取环境信息失败:', e)
      }
    }
    
    // 尝试从localStorage获取API URL，这是最可靠的方式
    try {
      const savedApiUrl = localStorage.getItem('apiBaseUrl')
      if (savedApiUrl) {
        apiUrl = savedApiUrl
      }
    } catch (e) {
      console.warn('无法从localStorage获取API URL:', e)
    }
    
    // 如果localStorage中没有，尝试获取用户设置
    if (!apiUrl) {
      try {
        // 检查是否可以安全访问Pinia
        if (typeof window !== 'undefined' && window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
          // Vue开发工具存在，说明Vue应用可能已经初始化
          try {
            const { useSettingsStore } = require('../stores/settings')
            const settingsStore = useSettingsStore()
            if (settingsStore.apiBaseUrl) {
              apiUrl = settingsStore.apiBaseUrl
              // 同步到localStorage
              localStorage.setItem('apiBaseUrl', apiUrl)
            }
          } catch (e) {
            console.warn('无法获取settings store，使用环境变量:', e)
          }
        }
      } catch (e) {
        // 忽略所有错误，使用环境变量
      }
    }
    
    // 如果用户没有设置或获取失败，则使用环境变量
    if (!apiUrl) {
      apiUrl = import.meta.env.VITE_API_BASE_URL || 'http://127.0.0.1:8080'
    }
    
    console.log(`API URL: ${apiUrl}`)
    
    return apiUrl
  }
}

// 导出单例实例 - 延迟初始化
let apiConfigInstance: ApiConfig | null = null

export const apiConfig = {
  getInstance: (): ApiConfig => {
    if (!apiConfigInstance) {
      apiConfigInstance = ApiConfig.getInstance()
    }
    return apiConfigInstance
  },
  getAxiosInstance: () => {
    return apiConfig.getInstance().getAxiosInstance()
  }
}